Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/misc/volume6/glib/part05

Text File | 1989-05-14 | 46.5 KB | 2,364 lines

Newsgroups: comp.sources.misc
From: [e-mail] (Brandon S. Allbery - comp.sources.misc)
Subject: v06i106: glib part 5 of 15
Reply-To: [e-mail] (Greg Lee )

Posting-number: Volume 6, Issue 106
Submitted-by: [e-mail] (Greg Lee )
Archive-name: glib/part05

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 5 (of 15)."
# Contents:  d10tra.mnu dw8000.mnu k5single.mnu vis.c
# Wrapped by lee@uhccux on Sun May  7 00:40:12 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'd10tra.mnu' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'d10tra.mnu'\"
else
echo shar: Extracting \"'d10tra.mnu'\" \(10615 characters\)
sed "s/^X//" >'d10tra.mnu' <<'END_OF_FILE'
X/* $Id: d10tra.mnu,v 1.6 89/05/06 17:13:17 lee Exp $
X * GLIB - a Generic LIBrarian and editor for synths
X *
X * D10 Rhythm Track Librarian
X *
X * Code started 2 FEB 89 --  Michael R. Kesti [e-mail]
X * modified by Greg Lee
X * $Log:    d10tra.mnu,v $
X * Revision 1.6  89/05/06  17:13:17  lee
X * rel. to comp.sources.misc
X *
X */
X
X#include "glib.h"
X#include "vis.h"
X
X#define D10TRASIZE 502
X#define TRABASEADDR 0x0c0000
X#define RESERVESIZE 20
X
Xchar *visnum(), *visonoff();
X
X
X/* This array contains arbitrary screen labels */
Xstruct labelinfo Ldtra[] = {
X#MENU
X
X
X
X
X
X
X
X
X
X
X
X
X               No Rhythm Track editing is supported.
X
X
X
X
X
X
X
X
X
X
X Press SPACE BAR to sound note %   at volume %   for duration %  on channel % .
X#END
X-1,-1,NULL
X};
X
Xstruct paraminfo  Pdtra[] =  {
X/*
XNAME        TYPE        POS    MAX    OFFSET    MASK    SHIFT    ADHOC
X */
X#O autopitch    num    %%    127    -60
X#O autovol    num    %%    127    -63
X#O autodur    num    %%    20    -5    *5
X#O autochan    num    %%    16    -1    *5
XNULL,NULL,-1,-1,-1,-1,visnum,0,0,0,0
X};
X
X/*
X * dtranum
X *
X * Convert a voice number (0) to the string displayed in the
X * librarian (ie. 1).
X */
X
Xchar *
Xdtranum(n)
X{
X    if ( n != 0 )
X        return("??");
X    return("01");
X}
X
X/*
X * dnumtra
X *
X * Convert a display-style voice number (1) to internal
X * format (0).
X */
X
Xdnumtra(n)
Xint n;
X{
X    if(n != 1) {
X        return(-1);
X    } else {
X        return(0);
X    }
X}
X
X/*
X * dtradin
X *
X * Take library bank 'data' and stuff values in the P array, by using
X * the setval function.
X */
X
Xdtradin(data)
Xchar *data;
X{
X    /* The first RESERVESIZE bytes are reserved (arbitrarily) for the voice name */
X}
X
X/*
X * dtradout
X *
X * Take (possibly changed) parameters values out of the P array and
X * put them back into the library bank 'data'.
X */
X
Xdtradout(data)
Xchar *data;
X{
X}
X
X/*
X * dtrasedit
X *
X * Send a single voice to the edit buffer of the D10.  This will be whatever
X * voice is currently selected.
X */
X
Xdtrasedit(data)
Xchar *data;
X{
X}
X
X/*
X * dtranof
X *
X * Return a pointer to the voice name buried in library bank data.
X */
Xchar *
Xdtranof(data)
Xchar *data;
X{
X    static char buf[12];
X    int n;
X
X    for(n = 0; n < D10TRASIZE; n++)
X        if ( data[n + RESERVESIZE] != 0 ) break;
X    if ( n != D10TRASIZE ) {
X        n = data[RESERVESIZE + 0] + (data[RESERVESIZE + 1] << 7);
X        sprintf(buf, "%d patterns", n);
X    } else
X        strcpy(buf, "           ");
X    return(buf);
X}
X
X/*
X * dtrasnof
X *
X * Set the voice name buried in data to name.
X */
Xdtrasnof(data,name)
Xchar *data;
Xchar *name;
X{
X}
X
X/* dtrasone - send a single voice to the D10 */
Xdtrasone(iv, data)
Xint iv;
Xchar *data;
X{
X    int n;
X    int cksum;
X    long curadd;
X    int addbyte;
X
X    curadd = TRABASEADDR;
X
X    sendmidi(0xf0);
X    sendmidi(0x41);
X    sendmidi(0x10);
X    sendmidi(0x16);
X    sendmidi(0x12);        /* DT1 - Data set 1 command */
X
X    addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X    sendmidi(addbyte);
X    cksum = addbyte;
X    addbyte = ((curadd >> 8) & 0x7f);
X    sendmidi(addbyte);
X    cksum += addbyte;
X    addbyte = (curadd & 0x7f);        /* address lsb */
X    sendmidi(addbyte);
X    cksum += addbyte;
X
X    for(n = 0; n < 256; n++) {
X        sendmidi(data[n + RESERVESIZE] & 0x7f);
X        cksum += data[n + RESERVESIZE] & 0x7f;
X    }
X
X    sendmidi((-cksum) & 0x7f);    /* checksum */
X    sendmidi(EOX);
X
X    curadd = 0x0c0200;
X
X    sendmidi(0xf0);
X    sendmidi(0x41);
X    sendmidi(0x10);
X    sendmidi(0x16);
X    sendmidi(0x12);        /* DT1 - Data set 1 command */
X
X    addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X    sendmidi(addbyte);
X    cksum = addbyte;
X    addbyte = ((curadd >> 8) & 0x7f);
X    sendmidi(addbyte);
X    cksum += addbyte;
X    addbyte = (curadd & 0x7f);        /* address lsb */
X    sendmidi(addbyte);
X    cksum += addbyte;
X
X    for(n = 256; n < 512; n++) {
X        sendmidi(data[n + RESERVESIZE] & 0x7f);
X        cksum += data[n + RESERVESIZE] & 0x7f;
X    }
X
X    sendmidi((-cksum) & 0x7f);    /* checksum */
X    sendmidi(EOX);
X
X    curadd = 0x0c0400;
X
X    sendmidi(0xf0);
X    sendmidi(0x41);
X    sendmidi(0x10);
X    sendmidi(0x16);
X    sendmidi(0x12);        /* DT1 - Data set 1 command */
X
X    addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X    sendmidi(addbyte);
X    cksum = addbyte;
X    addbyte = ((curadd >> 8) & 0x7f);
X    sendmidi(addbyte);
X    cksum += addbyte;
X    addbyte = (curadd & 0x7f);        /* address lsb */
X    sendmidi(addbyte);
X    cksum += addbyte;
X
X    for(n = 512; n < (D10TRASIZE - 512); n++) {
X        sendmidi(data[n + RESERVESIZE] & 0x7f);
X        cksum += data[n + RESERVESIZE] & 0x7f;
X    }
X
X    sendmidi((-cksum) & 0x7f);    /* checksum */
X    sendmidi(EOX);
X
X    return(0);
X}
X
X/* dtragbulk - Request and read a bulk dump from the D10 */
Xdtragbulk(data)
Xchar *data;
X{
X    static    char Buff[BUFSIZ];
X    int n, v, b2, ret = 1;
X    long begin, toolong;
X    long curadd;
X    int addbyte;
X    int cksum;
X
X    sprintf(Buff,"\n");
X    windstr(Buff);
X
X    curadd = TRABASEADDR;
X
X    for(v = 0; v < Nvoices; v++) {
X
X        flushmidi();
X
X        if(v % 10 != 0) {
X            sprintf(Buff, ".");
X        } else {
X            sprintf(Buff,"%d", (v / 10));
X        }
X        windstr(Buff);
X
X    /* request the voice */
X        sendmidi(0xf0);
X        sendmidi(0x41);
X        sendmidi(0x10);
X        sendmidi(0x16);
X        sendmidi(0x11);        /* RQ1 - Data request 1 command */
X
X        addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X        sendmidi(addbyte);
X        cksum = addbyte;
X        addbyte = ((curadd >> 8) & 0x7f);
X        sendmidi(addbyte);
X        cksum += addbyte;
X        addbyte = (curadd & 0x7f);        /* address lsb */
X        sendmidi(addbyte);
X        cksum += addbyte;
X
X        sendmidi(0x00);        /* length msb */
X        cksum += 0x00;
X        sendmidi(0x03);        /* should be D10TRASIZE */
X        cksum += 0x03;
X        sendmidi(0x76);        /* length lsb */
X        cksum += 0x76;
X
X        sendmidi((-cksum) & 0x7f);    /* checksum */
X        sendmidi(EOX);
X
X    /* set up timeout */
X        begin = milliclock();
X        toolong = begin + (1000 * TIMEOUT);
X
X    /* read header */
X        for(n = 0; n < 8; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout waiting for header";
X                    goto getout;
X                }
X            }
X        }
X
X    /* read data */
X        for(n = 0; n < 256; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8)) {
X                    VOICEBYTE(data,v,n + RESERVESIZE) = b2;
X                    n++;
X                }
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading data";
X                    goto timeout0;
X                }
X            }
X        }
X
X    timeout0:
X        if ( n != 256 ) {
X            Reason = "Timeout reading data!";
X            goto getout;
X        }
X
X    /* read checksum */
X        for(n = 0; n < 1; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading checksum";
X                    goto getout;
X                }
X            }
X        }
X
X    /* read EOX */
X        for(n = 0; n < 1; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    if ( b2 != EOX ) {
X                        sprintf(Buff,"EOX not received (%X)\n", b2);
X                        Reason = Buff;
X                        goto getout;
X                    }
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading EOX";
X                    goto getout;
X                }
X            }
X        }
X
X    /* read header */
X        for(n = 0; n < 8; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout waiting for header";
X                    goto getout;
X                }
X            }
X        }
X
X    /* read data */
X        for(n = 0; n < 246; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8)) {
X                    VOICEBYTE(data,v,n + RESERVESIZE + 256) = b2;
X                    n++;
X                }
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading data";
X                    goto timeout1;
X                }
X            }
X        }
X
X    timeout1:
X        if ( n != 246 ) {
X            Reason = "Timeout reading data!";
X            goto getout;
X        }
X
X    /* read checksum */
X        for(n = 0; n < 1; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading checksum";
X                    goto getout;
X                }
X            }
X        }
X
X    /* read EOX */
X        for(n = 0; n < 1; ) {
X            if ( STATMIDI ) {
X                b2 = (getmidi() & 0xff);
X                /* burn active sensing and timing clock */
X                if((b2 != 0xfe) && (b2 != 0xf8))
X                    if ( b2 != EOX ) {
X                        sprintf(Buff,"EOX not received (%X)\n", b2);
X                        Reason = Buff;
X                        goto getout;
X                    }
X                    n++;
X            } else {
X                if ( milliclock() > toolong ) {
X                    Reason = "Timeout reading EOX";
X                    goto getout;
X                }
X            }
X        }
X
X        curadd += 0x376;        /* D10TRASIZE */
X
X        if((curadd & 0x80) != 0) {
X            curadd &= 0x7fff7f;
X            curadd += 0x100;
X        }
X        if((curadd & 0x8000) != 0) {
X            curadd &= 0x7f7f7f;
X            curadd += 0x10000;
X        }
X    } /* go back for another voice */
X
X    Reason = "";
X    ret = 0;    /* all's well */
X
Xgetout:
X    return(ret);
X}
X
X/* dtrasbulk - send a bulk dump to the D10 */
Xdtrasbulk(data)
Xchar *data;
X{
X    int n;
X    int cksum;
X    long curadd;
X    int addbyte;
X
X    curadd = TRABASEADDR;
X
X    sendmidi(0xf0);
X    sendmidi(0x41);
X    sendmidi(0x10);
X    sendmidi(0x16);
X    sendmidi(0x12);        /* DT1 - Data set 1 command */
X
X    addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X    sendmidi(addbyte);
X    cksum = addbyte;
X    addbyte = ((curadd >> 8) & 0x7f);
X    sendmidi(addbyte);
X    cksum += addbyte;
X    addbyte = (curadd & 0x7f);        /* address lsb */
X    sendmidi(addbyte);
X    cksum += addbyte;
X
X    for(n = 0; n < 256; n++) {
X        sendmidi(data[n + RESERVESIZE] & 0x7f);
X        cksum += data[n + RESERVESIZE] & 0x7f;
X    }
X
X    sendmidi((-cksum) & 0x7f);    /* checksum */
X    sendmidi(EOX);
X
X    curadd = 0x0c0200;
X
X    sendmidi(0xf0);
X    sendmidi(0x41);
X    sendmidi(0x10);
X    sendmidi(0x16);
X    sendmidi(0x12);        /* DT1 - Data set 1 command */
X
X    addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X    sendmidi(addbyte);
X    cksum = addbyte;
X    addbyte = ((curadd >> 8) & 0x7f);
X    sendmidi(addbyte);
X    cksum += addbyte;
X    addbyte = (curadd & 0x7f);        /* address lsb */
X    sendmidi(addbyte);
X    cksum += addbyte;
X
X    for(n = 256; n < 512; n++) {
X        sendmidi(data[n + RESERVESIZE] & 0x7f);
X        cksum += data[n + RESERVESIZE] & 0x7f;
X    }
X
X    sendmidi((-cksum) & 0x7f);    /* checksum */
X    sendmidi(EOX);
X
X    curadd = 0x0c0400;
X
X    sendmidi(0xf0);
X    sendmidi(0x41);
X    sendmidi(0x10);
X    sendmidi(0x16);
X    sendmidi(0x12);        /* DT1 - Data set 1 command */
X
X    addbyte = ((curadd >> 16) & 0x7f);    /* address msb */
X    sendmidi(addbyte);
X    cksum = addbyte;
X    addbyte = ((curadd >> 8) & 0x7f);
X    sendmidi(addbyte);
X    cksum += addbyte;
X    addbyte = (curadd & 0x7f);        /* address lsb */
X    sendmidi(addbyte);
X    cksum += addbyte;
X
X    for(n = 512; n < (D10TRASIZE - 512); n++) {
X        sendmidi(data[n + RESERVESIZE] & 0x7f);
X        cksum += data[n + RESERVESIZE] & 0x7f;
X    }
X
X    sendmidi((-cksum) & 0x7f);    /* checksum */
X    sendmidi(EOX);
X
X    return(0);
X}
X
X/* end */
END_OF_FILE
if test 10615 -ne `wc -c <'d10tra.mnu'`; then
    echo shar: \"'d10tra.mnu'\" unpacked with wrong size!
fi
# end of 'd10tra.mnu'
fi
if test -f 'dw8000.mnu' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'dw8000.mnu'\"
else
echo shar: Extracting \"'dw8000.mnu'\" \(10982 characters\)
sed "s/^X//" >'dw8000.mnu' <<'END_OF_FILE'
X/* $Id: dw8000.mnu,v 1.6 89/05/06 17:13:21 lee Exp $
X * GLIB - a Generic LIBrarian and editor for synths
X *
X * DW8000 Librarian
X *
X * Code completed 8/24/87 --  Steven A. Falco  moss!saf
X * modifications: Greg Lee
X * $Log:    dw8000.mnu,v $
X * Revision 1.6  89/05/06  17:13:21  lee
X * rel. to comp.sources.misc
X *
X */
X
X#define OVERLAY2
X
X#include "glib.h"
X
X#define DW8VSIZE 51
X
Xchar *visnum(), *visd8wave(), *visd8oct(), *visd8trk();
Xchar *visd8ival(), *visd8detu(), *visdasel(), *dw8vnum(), *visdamod();
Xchar *visdmgw(), *visdmode(), *visd8pol(),*visd8sem(), *visonoff();
X
X#define RESERVESIZE 20
X
X#define visdw8vnum dw8vnum
X/* This array contains arbitrary screen labels */
Xstruct labelinfo  Ldw800[] =  {
X#MENU
X
X
X+----------------------------------+----------------+------------------+------+
X|         Osc 1     Osc 2     Noise|          ModGen|          AutoBend| Mode |
X|Octave   %         %              |Waveform  %     |Select    %       |%     |
X|Waveform %         %              |Frequency %     |Mode      %       |      |
X|Level    %         %         %    |Delay     %     |Time      %       |      |
X|Interval           %              |Osc       %     |Intensity %       |      |
X|Detune             %              |VCF       %     |                  |      |
X+------------------+---------------+----------------+------------------+------+
X|          VCF  VCA|          Delay|    Joystick    |     Portamento   |Key   |
X|Attack    %    %  |Time      %    |Osc %           |Time %            |Param |
X|Decay     %    %  |Factor    %    |VCF %           |                  |%     |
X|Break Pt. %    %  |Feedback  %    +----------------+------------------+------+
X|Slope     %    %  |Frequency %    |
X|Sustain   %    %  |Intensity %    | +-------------------------+--------------+
X|Release   %    %  |Eff.Level %    | |Space = Play Note        | Auto-Note    |
X|V.Sensitv %    %  +---------------+ |                         |              |
X|Cutoff    %       |       AftTouch| |h = left   q = quit      |Pitch    %    |
X|Resonance %       |Osc.MG %       | |j = down   N = Set Name  |Duration %    |
X|Tracking  %       |VCF    %       | |k = up     J = Decrement |Volume   %    |
X|Polarity  %       |VCA    %       | |l = right  K = Increment |Channel  %    |
X|EG.Intens %       |               | |                         |              |
X+------------------+---------------+ +-------------------------+--------------+
X#END
X-1,-1,NULL
X};
X
X/* This array defines all the editable parameters. */
Xstruct paraminfo  Pdw800[] =  {
X/*
XNAME        TYPE    POS    MAX    OFFSET    MASK    SHIFT    ADHOC
X */
X#O o1oct    d8oct    %%    3    0
X#O o2oct    d8oct    %%    3    7
X#O mgwave    dmgw    %%    3    34
X#O abndsel    dasel    %%    3    3
X#O mode        dmode    %%    3    13
X#O o1wave    d8wave    %%    15    1
X#O o2wave    d8wave    %%    15    8
X#O mgfrew    num    %%    31    35
X#O abndmod    damod    %%    1    4
X#O o1lev    num    %%    31    2
X#O o2lev    num    %%    31    9
X#O noise    num    %%    31    12
X#O mgdela    num    %%    31    36
X#O abndtim    num    %%    31    5
X#O o2ival    d8ival    %%    7    10
X#O mgosc    num    %%    31    37
X#O abndins    num    %%    31    6
X#O o2detu    d8detu    %%    7    11
X#O mgvcf    num    %%    31    38
X#O fatt        num    %%    31    20
X#O aatt        num    %%    31    27
X#O dtim        num    %%    7    41
X#O joyosc    d8sem    %%    15    39
X#O portam    num    %%    31    47
X#O fdec        num    %%    31    21
X#O adec        num    %%    31    28
X#O dfact    num    %%    15    42
X#O joyvcf    onoff    %%    1    40
X#O vnumb    dw8vnum    %%    63    14
X#O fbrk        num    %%    31    22
X#O abrk        num    %%    31    29
X#O dfeed    num    %%    15    43
X#O fslp        num    %%    31    23
X#O aslp        num    %%    31    30
X#O dfreq    num    %%    31    44
X#O fsus        num    %%    31    24
X#O asus        num    %%    31    31
X#O dintns    num    %%    31    45
X#O frel        num    %%    31    25
X#O arel        num    %%    31    32
X#O deff        num    %%    15    46
X#O asens    num    %%    7    33
X#O fsens    num    %%    7    26
X#O fcut        num    %%    63    15
X#O autopitch    num    %%    127    -60
X#O fres        num    %%    31    16
X#O autovol    num    %%    127    -63
X#O atosc    num    %%    3    48
X#O ftrk        d8trk    %%    3    17
X#O autodur    num    %%    20    -5    *5
X#O atvcf    num    %%    3    49
X#O fpol        d8pol    %%    1    18
X#O autochan    num    %%    16    -1    *5
X#O atvca    num    %%    3    50
X#O fegi        num    %%    31    19
XNULL,NULL,-1,-1,-1,-1,visnum,0,0,0,0
X};
X
X
X/*
X * dw8vnum
X *
X * Convert a voice number (0 to 63) to the string displayed in the
X * librarian (ie. 11 to 88).
X */
X/* added vis to beginning of this name -- gl */
Xchar *
Xdw8vnum(n)
X{
X    static char v[3];
X
X    if ( n < 0 || n > 63 )
X        return("??");
X
X    v[0] = n/8 + '1';
X    v[1] = n%8 + '1';
X    v[2] = '\0';
X    return(v);
X}
X
X/*
X * dw8numv
X *
X * Convert a display-style voice number (11 to 88) to internal
X * format (0 - 63).
X */
X
Xdw8numv(n)
Xint n;
X{
X    int ld, rd;
X
X    /* crack out the digits as octal codes */
X    ld = (n / 10) - 1; /* left digit */
X    rd = (n % 10) - 1; /* right digit */
X
X    if(ld < 0 || ld > 7 || rd < 0 || rd > 7) {
X        return(-1);
X    } else {
X        return(ld * 8 + rd); /* combine as octal */
X    }
X}
X
X/*
X * dw8din
X *
X * Take library bank 'data' and stuff values in the P array, by using
X * the setval function.
X */
X
Xdw8din(data)
Xchar *data;
X{
X    /* The first 20 bytes are reserved (arbitrarily) for the voice name */
X#SETVAL
X    /* We set the 'auto-note' channel upon entry */
X    setval("autochan",Channel);
X}
X
X/*
X * dw8dout
X *
X * Take (possibly changed) parameters values out of the P array and
X * put them back into the library bank 'data'.
X */
X
Xdw8dout(data)
Xchar *data;
X{
X#GETVAL
X    /* If the autochan parameter has changed, update Channel */
X    Channel = getval("autochan");
X}
X
X/*
X * dw8sedit
X *
X * Send a single voice to the edit buffer of the DW8000.  This will be whatever
X * voice is currently selected.
X */
X
Xdw8sedit(data)
Xchar *data;
X{
X    int n;
X
X    sendmidi(0xf0);
X    sendmidi(0x42);
X    sendmidi(0x30 | (Channel - 1));
X    sendmidi(0x03);
X    sendmidi(0x40);
X    for(n = 0; n < DW8VSIZE; n++) {
X        sendmidi(data[n + 20] & 0x7f);
X    }
X    sendmidi(EOX);
X}
X
X/*
X * dw8nof
X *
X * Return a pointer to the voice name buried in library bank data.
X */
Xchar *
Xdw8nof(data)
Xchar *data;
X{
X    static char currbuff[17];
X    char *p;
X    int m;
X
X    p = currbuff;
X    for ( m=0; m<16; m++ )
X        *p++ = data[m];
X    *p = '\0';
X    return(currbuff);
X}
X
X/*
X * dw8snof
X *
X * Set the voice name buried in data to name.
X */
Xdw8snof(data,name)
Xchar *data;
Xchar *name;
X{
X    char *p;
X    int m;
X
X    for ( p=name,m=0; *p!='\0' && m<16; p++,m++ )
X        data[m] = *p;
X    for ( ; m<16; m++ )
X        data[m] = ' ';
X}
X
X/* dw8sone - send a single voice to the DW8000 */
Xdw8sone(iv, data)
Xint iv;
Xchar *data;
X{
X    int c, b2, ret = 1;
X    long begin, toolong;
X
X    /* select voice n */
X    sendmidi(0xc0 | (Channel - 1));
X    sendmidi(iv);
X
X    /* send data */
X    dw8sedit(data);
X
X    /* request write */
X    sendmidi(0xf0);
X    sendmidi(0x42);
X    sendmidi(0x30 | (Channel - 1));
X    sendmidi(0x03);
X    sendmidi(0x11);    /* write request */
X    sendmidi(iv);    /* the now-current voice */
X    sendmidi(EOX);
X
X    /* read the ack/nack - set up for timeout */
X    begin = milliclock();
X    toolong = begin + 1000 * TIMEOUT;
X
X    /* wait for the 0x03 byte (dw8000 ID byte) */
X    while ( milliclock() < toolong ) {
X        if ( STATMIDI && (c=(getmidi() & 0xff)) == 0x03 )
X            break;
X    }
X    if ( c != 0x03 ) {
X        Reason = "Timeout waiting for 0x03";
X        goto getout;
X    }
X
X    /* next byte is the result code */
X    while((b2 = getmidi() & 0xff) == 0xfe)
X        ; /* burn active sensing */
X    if(b2 != 0x21) {
X        Reason = "Write failed - check protect switch!";
X        goto getout;
X    }
X
X    while((b2 = getmidi() & 0xff) == 0xfe)
X        ;    /* want EOX - burn active sensing */
X    if ( b2 != EOX )
X        Reason = "EOX not received";
X    else {
X        Reason = "";
X        ret = 0;    /* all's well */
X    }
X
Xgetout:
X    return(ret);
X}
X
X/* dw8gbulk - Request and read a bulk dump from the DW8000 */
Xdw8gbulk(data)
Xchar *data;
X{
X    int c, n, v, b2, ret = 1;
X    long begin, toolong;
X
X    flushmidi();
X
X    for(v = 0; v < Nvoices; v++) {
X        /* select voice */
X        sendmidi(0xc0 | (Channel - 1));
X        sendmidi(v);
X
X        /* request the voice */
X        sendmidi(0xf0);
X        sendmidi(0x42);
X        sendmidi(0x30 | (Channel-1));    /* Channel # */
X        sendmidi(0x03);
X        sendmidi(0x10);
X        sendmidi(EOX);
X
X        /* set up for timeout */
X        begin = milliclock();
X        toolong = begin + 1000 * TIMEOUT;
X
X        /* wait for the x40 byte starting the dump */
X        while ( milliclock() < toolong ) {
X            if ( STATMIDI && (c=(getmidi() & 0xff)) == 0x40 )
X                break;
X        }
X        if ( c != 0x40 ) {
X            Reason = "Timeout waiting for 0x40";
X            goto getout;
X        }
X
X        /* now read 51 bytes of voice data */
X        for(n = 0; n < DW8VSIZE; n++) {
X            /* twiddle your thumbs, but not forever */
X            while ( ! STATMIDI ) {
X                if ( milliclock() > toolong )
X                    goto timeout;    /* the end of an era */
X            }
X            while((b2 = getmidi() & 0xff) == 0xfe)
X                ; /* burn active sensing */
X            VOICEBYTE(data,v,n + 20) = b2;
X        }
X
X    timeout:
X        if ( n != DW8VSIZE ) {
X            Reason = "Timeout while reading!";
X            goto getout;
X        }
X        while((b2 = getmidi() & 0xff) == 0xfe)
X            ;    /* want EOX - burn active sensing */
X        if ( b2 != EOX )
X            Reason = "EOX not received";
X        else {
X            Reason = "";
X            ret = 0;    /* all's well */
X        }
X    } /* go back for another voice */
X
Xgetout:
X    return(ret);
X}
X
X/*
X * Below are functions used for display of parameter values
X */
X
Xchar *
Xvisd8wave(v)
X{
X    switch (v) {
X    case 0: return("ramp");
X    case 1: return("square");
X    case 2: return("ac. piano");
X    case 3: return("el. piano");
X    case 4: return("hd. piano");
X    case 5: return("clavinet");
X    case 6: return("organ");
X    case 7: return("brass");
X    case 8: return("sax");
X    case 9: return("violin");
X    case 10: return("a. guitar");
X    case 11: return("d. guitar");
X    case 12: return("el. bass");
X    case 13: return("dg. bass");
X    case 14: return("bell");
X    case 15: return("sine");
X    }
X    return("*");
X}
X
Xchar *
Xvisd8oct(v)
X{
X    switch(v) {
X    case 0: return("16");
X    case 1: return("8");
X    case 2: return("4");
X    case 3: return("*");
X    }
X    return("*");
X}
X
Xchar *
Xvisd8ival(v)
X{
X    switch(v) {
X    case 0: return("unison");
X    case 1: return("min 3rd");
X    case 2: return("maj 3rd");
X    case 3: return("4th");
X    case 4: return("5th");
X    case 5: case 6: case 7: return("*");
X    }
X    return("*");
X}
X
Xchar *
Xvisd8detu(v)
X{
X    switch(v) {
X    case 0: return("in tune");
X    case 1: return("1 cent");
X    case 2: return("2 cents");
X    case 3: return("3 cents");
X    case 4: return("4 cents");
X    case 5: return("5 cents");
X    case 6: return("6 cents");
X    case 7: return("*");
X    }
X    return("*");
X}
X
Xchar *Semicode[] = {
X    "none",
X    "1 semitone",
X    "2 semitones",
X    "3 semitones",
X    "4 semitones",
X    "5 semitones",
X    "6 semitones",
X    "7 semitones",
X    "8 semitones",
X    "9 semitones",
X    "10 semitones",
X    "11 semitones",
X    "1 octave"
X};
X
Xchar *
Xvisd8sem(v)
X{
X    if(v >= 0 && v <= 12) {
X        return(Semicode[v]);
X    }
X    return("*");
X}
X
Xchar *
Xvisdasel(v)
X{
X    switch(v) {
X    case 0: return("off");
X    case 1: return("Osc 1");
X    case 2: return("Osc 2");
X    case 3: return("Osc 1+2");
X    }
X    return("*");
X}
X
Xchar *
Xvisdamod(v)
X{
X    switch(v) {
X    case 0: return("Up");
X    case 1: return("Down");
X    }
X    return("*");
X}
X
Xchar *
Xvisd8pol(v)
X{
X    switch(v) {
X    case 0: return("/-\\");
X    case 1: return("\\_/");
X    }
X    return("*");
X}
X
Xchar *
Xvisdmode(v)
X{
X    switch(v) {
X    case 0: return("Poly 1");
X    case 1: return("Poly 2");
X    case 2: return("Uni 1");
X    case 3: return("Uni 2");
X    }
X    return("*");
X}
X
Xchar *
Xvisdmgw(v)
X{
X    switch(v) {
X    case 0: return("/\\");
X    case 1: return("|\\");
X    case 2: return("/|");
X    case 3: return("_|-|");
X    }
X    return("*");
X}
X
Xchar *
Xvisd8trk(v)
X{
X    switch(v) {
X    case 0: return("0");
X    case 1: return("1/4");
X    case 2: return("1/2");
X    case 3: return("1");
X    }
X    return("*");
X}
X
X/* end */
END_OF_FILE
if test 10982 -ne `wc -c <'dw8000.mnu'`; then
    echo shar: \"'dw8000.mnu'\" unpacked with wrong size!
fi
# end of 'dw8000.mnu'
fi
if test -f 'k5single.mnu' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'k5single.mnu'\"
else
echo shar: Extracting \"'k5single.mnu'\" \(10747 characters\)
sed "s/^X//" >'k5single.mnu' <<'END_OF_FILE'
X/* $Id: k5single.mnu,v 1.6 89/05/06 17:13:30 lee Exp $
X * GLIB - a Generic LIBrarian and editor for synths
X *
X * Kawai K-5 Librarian - handles SINGLE (and MULTI) patches.
X * Functions are annotated if they work for SINGLE, MULTI, or both kinds.
X * Full editing not implemented - there are zillions of parameters,
X * and the huge LCD on the K-5 is actually quite easy to read and use.
X *
X * Alan Bland - att!druwy!mab
X * mod. Greg Lee
X * $Log:    k5single.mnu,v $
X * Revision 1.6  89/05/06  17:13:30  lee
X * rel. to comp.sources.misc
X *
X */
X
X#define OVERLAY2
X
X#include "glib.h"
X#ifdef BSD
X#include <ctype.h>
X#endif
X
X#define K5SINGLE    0
X#define K5MULTI        1
X#define K5MAGIC        0x5a3c
X
X#define NERRS        5
X#define RESERVESIZE    0
X
Xextern char *visnum();
X
X/* This array contains arbitrary screen labels (SINGLE) */
Xstruct labelinfo Lk5s[] = {
X#MENU
X
X
X
X          Sorry, no edit capability implemented for the K-5 yet.
X
X
X
X
X
X
X
X
X
X
X
X  +-------------------------+--------------+
X  |Space = Play Note        | Auto-Note    |
X  |                         |              |
X  |h = left   q = quit      |Pitch    %    |
X  |j = down   N = Set Name  |Volume   %    |
X  |k = up     J = Decrement |Duration %    |
X  |l = right  K = Increment |Channel  %    |
X  |                         |              |
X  +-------------------------+--------------+
X#END
X-1,-1,NULL
X};
X
Xstruct paraminfo  Pk5s[] =  {
X/*
XNAME        TYPE    POS    MAX    OFFSET    MASK    SHIFT    ADHOC
X */
X#O autopitch    num    %%    127    -60
X#O autovol    num    %%    127    -63
X#O autodur    num    %%    20    -5    *5
X#O autochan    num    %%    16    -1    *5
XNULL,NULL,-1,-1,-1,-1,visnum,0,0,0,0
X};
X
X
X
X/*
X * k5vnum
X *
X * Convert a voice number (0 to 47) to the string displayed in the
X * librarian (A1-D12)  (SINGLE and MULTI)
X */
Xchar *
Xk5vnum(n)
Xregister int n;
X{
X    static char v[4];
X
X    if ( n < 0 || n > 47 )
X        return("??");
X
X    sprintf(v, "%c%d", n/12 + 'A', n%12 + 1);
X    return(v);
X}
X
X/*
X * k5numv
X *
X * Convert an alphanumeric voice number (A1-D12) to internal
X * format (0 - 47).  (SINGLE and MULTI)
X */
Xk5numv(n)
Xregister char *n;
X{
X    register int v,j;
X
X    /* first better be [a-dA-D] */
X    *n = toupper(*n);
X    if (*n == 'A' || *n == 'B' || *n == 'C' || *n == 'D') {
X        v = 12 * (*n - 'A');
X    } else {
X        return(-1);
X    }
X
X    /* followed by 1-12 */
X    j = atoi(++n);
X    if (j<1 || j>12) return(-1);
X    return v + j - 1;
X}
X
X/*
X * k5sdin
X *
X * Take library bank 'data' and stuff values in the P array, by using
X * the setval function.
X */
Xk5sdin(data)
Xchar *data;
X{
X    /* We set the 'auto-note' channel upon entry */
X    setval("autochan",Channel);
X}
X
X/*
X * k5sdout
X *
X * Take (possibly changed) parameters values out of the P array and
X * put them back into the library bank 'data'.
X */
Xk5sdout(data)
Xchar *data;
X{
X    /* If the autochan parameter has changed, update Channel */
X    Channel = getval("autochan");
X}
X
X/*
X * k5mdin
X *
X * Take library bank 'data' and stuff values in the P array, by using
X * the setval function.
X */
Xk5mdin(data)
Xchar *data;
X{
X    /* We set the 'auto-note' channel upon entry */
X    setval("autochan",Channel);
X}
X
X/*
X * k5mdout
X *
X * Take (possibly changed) parameters values out of the P array and
X * put them back into the library bank 'data'.
X */
Xk5mdout(data)
Xchar *data;
X{
X    /* If the autochan parameter has changed, update Channel */
X    Channel = getval("autochan");
X}
X
X/*
X * k5snof
X *
X * Return a pointer to the voice name buried in library bank data. (SINGLE)
X */
Xchar *
Xk5snof(data)
Xregister char *data;
X{
X    static char currbuff[9];
X    register char *p;
X    register int m;
X
X    p = currbuff;
X    for ( m=0; m<16; m+=2 )
X        *p++ = (data[m]<<4) | data[m+1];
X    *p = '\0';
X    return(currbuff);
X}
X
X/*
X * k5nameok
X *
X * Convert an ascii string to the ascii subset used for K5 names.
X */
Xchar*
Xk5nameok(name)
Xchar *name;
X{
X    static char okname[9];
X    register int m;
X
X    for (m=0; m<9 && name[m]; ++m) {
X        okname[m] = toupper(name[m]);
X        if (!isalnum(okname[m])) {
X            switch (okname[m]) {
X            case '-': case ':': case '/': case '*': case '?':
X            case '!': case '#': case '&': case '(': case ')':
X            case '"': case '+': case '.': case '=': case ' ':
X                break;
X            default:
X                okname[m] = ' ';
X                break;
X            }
X        }
X    }
X    okname[m] = '\0';
X    return okname;
X}
X
X/*
X * k5ssnof
X *
X * Set the voice name buried in data to name. (SINGLE)
X */
Xk5ssnof(data,name)
Xchar *data;
Xchar *name;
X{
X    register char *p;
X    register int m;
X
X    for ( p=k5nameok(name),m=0; *p!='\0' && m<17; p++,m+=2 ) {
X        data[m] = (*p & 0xf0) >> 4;
X        data[m+1] = *p & 0x0f;
X    }
X    for ( ; m<17; m+=2 ) {
X        data[m] = (' ' & 0xf0) >> 4;
X        data[m+1] = ' ' & 0x0f;
X    }
X}
X/*
X * k5mnof
X *
X * Return a pointer to the voice name buried in library bank data. (MULTI)
X */
Xchar *
Xk5mnof(data)
Xchar *data;
X{
X    static char currbuff[9];
X    register char *p;
X    register int m;
X
X    p = currbuff;
X    for ( m=0; m<16; m+=2 )
X        *p++ = (data[m+330]<<4) | data[m+331];
X    *p = '\0';
X    return(currbuff);
X}
X
X/*
X * k5msnof
X *
X * Set the voice name buried in data to name. (MULTI)
X */
Xk5msnof(data,name)
Xchar *data;
Xchar *name;
X{
X    char *p;
X    int m;
X
X    for ( p=k5nameok(name),m=0; *p!='\0' && m<17; p++,m+=2 ) {
X        data[m+330] = (*p & 0xf0) >> 4;
X        data[m+331] = *p & 0x0f;
X    }
X    for ( ; m<17; m+=2 ) {
X        data[m+330] = (' ' & 0xf0) >> 4;
X        data[m+331] = ' ' & 0x0f;
X    }
X}
X
X/*
X * k5sbulk
X *
X * common function to send all voices to the K-5 (SINGLE and MULTI)
X */
Xk5sbulk(data, which)
Xchar *data;
Xint which;    /* K5SINGLE or K5MULTI */
X{
X    int n, err = 0;
X    message("");
X    for (n=0; n<Nvoices; ++n) {
X        for (err=0; err<NERRS; ++err) {
X            if (k5sone(n, &(VOICEBYTE(data,n,0)), which ) == 0 ) {
X                windputc('+');
X                windrefresh();
X                break;
X            }
X            windputc('-');
X            windrefresh();
X        }
X        if (err == NERRS) return(1);
X    }
X    return(0);
X}
X
X/*
X * k5ssbulk
X *
X * send all voices to the K-5 (SINGLE)
X */
Xk5ssbulk(data)
Xchar *data;
X{
X    return k5sbulk(data, K5SINGLE);
X}
X
X/*
X * k5msbulk
X *
X * send all voices to the K-5 (MULTI)
X */
Xk5msbulk(data)
Xchar *data;
X{
X    return k5sbulk(data, K5MULTI);
X}
X
X/*
X * k5ssone
X *
X * send one voice to the K-5 (SINGLE)
X */
Xk5ssone(iv, data)
Xint iv;
Xchar *data;
X{
X    return k5sone(iv, data, K5SINGLE);
X}
X
X/*
X * k5msone
X *
X * send one voice to the K-5 (MULTI)
X */
Xk5msone(iv, data)
X{
X    return k5sone(iv, data, K5MULTI);
X}
X
X/*
X * k5sone
X *
X * common function to send a SINGLE or MULTI voice to the K-5.
X */
Xk5sone(iv, data, which)
Xint iv;
Xregister char *data;
Xint which;    /* K5SINGLE or K5MULTI */
X{
X    register int i, sum;
X    int length;
X    int c = 0, ret = 1;
X    long begin, toolong;
X
X    flushmidi();
X
X    length = (which == K5SINGLE) ? 984 : 352;
X
X    /* calculate checksum */
X    for (sum=0, i=0; i<length-4; ) {
X        sum += data[i++] << 4;
X        sum += data[i++];
X        sum += data[i++] << 12;
X        sum += data[i++] << 8;
X    }
X
X    sum = K5MAGIC - sum;
X    data[length-4] = (sum & 0x00f0) >> 4;
X    data[length-3] = (sum & 0x000f);
X    data[length-2] = (sum & 0xf000) >> 12;
X    data[length-1] = (sum & 0x0f00) >> 8;
X
X    sendmidi(0xf0);
X    sendmidi(0x40);
X    sendmidi(Channel-1);
X    sendmidi(0x20);
X    sendmidi(0x00);
X    sendmidi(0x02);
X    sendmidi(which);
X    sendmidi(iv);
X
X    for (i=0; i<length; i++) sendmidi(data[i]);
X
X    sendmidi(EOX);
X
X    /* read the ack/nack - set up for timeout */
X    begin = milliclock();
X    toolong = begin + 1000 * TIMEOUT;
X
X    /* wait for the acknowledgement */
X    while ( milliclock() < toolong ) {
X        if ( STATMIDI && (c=(getmidi() & 0xff)) == 0xf0 )
X            break;
X    }
X    if ( c != 0xf0 ) {
X        Reason = "Timeout waiting for K-5 response";
X        goto getout;
X    }
X
X    /* third byte after the sysex begin is the result */
X    for (i=0; i<3; ) {
X        /* wait for midi byte or timeout */
X        while ( ! STATMIDI ) {
X            if ( milliclock() > toolong ) {
X                Reason = "Timeout waiting for K-5 response";
X                goto getout;
X            }
X        }
X        /* ignore active sensing */
X        if ((c = getmidi() & 0xff) != 0xfe) {
X            ++i;
X        }
X    }
X
X    /* check the result */
X    switch (c) {
X    case 0x40:
X        ret = 0;
X        Reason = "";
X        break;
X    case 0x41:
X        Reason = "K-5 write error";
X        break;
X    case 0x42:
X        Reason = "K-5 write error (protected)";
X        break;
X    case 0x43:
X        Reason = "K-5 write error (no card)";
X        break;
X    default:
X        Reason = "Wierd response (is that really a K-5 you have?)";
X        break;
X    }
X
Xgetout:
X    return(ret);
X}
X
Xk5ssedit()
X{
X}
X
Xk5msedit()
X{
X}
X
X/*
X * k5sgbulk
X *
X * get all internal SINGLE voices from K-5.
X */
Xk5sgbulk(data)
Xchar *data;
X{
X    return k5gbulk(data, K5SINGLE);
X}
X
X/*
X * k5mgbulk
X *
X * get all internal MULTI voices from K-5.
X */
Xk5mgbulk(data)
Xchar *data;
X{
X    return k5gbulk(data, K5MULTI);
X}
X
X/*
X * k5gbulk
X *
X * common routine - get all SINGLE or MULTI voices from K-5.
X */
Xk5gbulk(data, which)
Xregister char *data;
Xint which;    /* K5SINGLE or K5MULTI */
X{
X    int c, v, sumerr = 0;
X    register int n, i, sum;
X    long begin, toolong;
X
X    message("");
X    flushmidi();
X
X    for(v = 0; v < Nvoices; v++) {
X
Xretry:
X        if (which == K5MULTI) {
X            /* i don't know if this is a K-5 or Amiga problem */
X            /* but multi patch download seems to need this delay */
X            millisleep(500);
X        }
X        /* request the voice */
X        sendmidi(0xf0);
X        sendmidi(0x40);
X        sendmidi(Channel-1);
X        sendmidi(0x00);
X        sendmidi(0x00);
X        sendmidi(0x02);
X        sendmidi(which);
X        sendmidi(v);
X        sendmidi(EOX);
X
X        /* set up for timeout */
X        begin = milliclock();
X        toolong = begin + 1000 * TIMEOUT;
X
X        /* wait for the xf0 byte starting the dump */
X        while ( milliclock() < toolong ) {
X            if ( STATMIDI && (c=(getmidi() & 0xff)) == 0xf0 )
X                break;
X        }
X        if ( c != 0xf0 ) {
X            Reason = "Timeout waiting for dump from K-5";
X            return 1;
X        }
X/*printf("%02x ", c);*/
X        /* skip the next 7 bytes (remainder of sysex header) */
X        for (i=0; i<7; ) {
X            /* wait for midi byte or timeout */
X            while ( ! STATMIDI ) {
X                if ( milliclock() > toolong )
X                    goto timeout;
X            }
X            /* ignore active sensing */
X            if ((c = getmidi() & 0xff) != 0xfe) {
X                ++i;
X/*printf("%02x ", c);*/
X            }
X        }
X
X        /* read voice data until EOX */
X        n = 0;
X        while (1) {
X            /* wait for midi byte or timeout */
X            while ( ! STATMIDI ) {
X                if ( milliclock() > toolong )
X                    goto timeout;
X            }
X            if ((c = getmidi() & 0xff) == 0xfe) {
X                /* ignore active sensing */
X                continue;
X            } else if (c == EOX) {
X                /* finished */
X                break;
X            } else {
X                /* got a data byte */
X                VOICEBYTE(data,v,n) = c;
X                ++n;
X            }
X        }
X/*printf("got block n=%d\n", n);*/
X        /* verify the checksum */
X        for (sum=0, i=0; i<n-4; ) {
X            sum += data[i++] << 4;
X            sum += data[i++];
X            sum += data[i++] << 12;
X            sum += data[i++] << 8;
X        }
X
X        sum = K5MAGIC - sum;
X        if ((data[n-4] == (sum & 0x00f0) >> 4) &&
X            (data[n-3] == (sum & 0x000f)) &&
X            (data[n-2] == (sum & 0xf000) >> 12) &&
X            (data[n-1] == (sum & 0x0f00) >> 8)) {
X            sumerr = 0;
X            windputc('+');
X        } else {
X            /* retry a few times if checksum failed */
X            windputc('-');
X            if (sumerr++ >= NERRS) {
X                Reason = "Too many checksum errors!";
X                return(1);
X            }
X            goto retry;
X        }
X        windrefresh();
X
X    } /* go back for another voice */
X    Reason = "";
X    return(0);
X
Xtimeout:
X    Reason = "Timeout while reading!";
X    return(1);
X}
X
END_OF_FILE
if test 10747 -ne `wc -c <'k5single.mnu'`; then
    echo shar: \"'k5single.mnu'\" unpacked with wrong size!
fi
# end of 'k5single.mnu'
fi
if test -f 'vis.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'vis.c'\"
else
echo shar: Extracting \"'vis.c'\" \(10248 characters\)
sed "s/^X//" >'vis.c' <<'END_OF_FILE'
X/* $Id: vis.c,v 1.6 89/05/06 17:13:46 lee Exp $
X * GLIB - a Generic LIBrarian and editor for synths
X *
X * Data Display Routines
X *
X * Code started 16 JAN 89 --  Michael R. Kesti [e-mail]
X * $Log:    vis.c,v $
X * Revision 1.6  89/05/06  17:13:46  lee
X * rel. to comp.sources.misc
X *
X */
X
X#include <stdio.h>
X
X
Xchar *
Xvispan(v)
X{
X    switch (v) {
X    case 0: return("7>");
X    case 1: return("6>");
X    case 2: return("5>");
X    case 3: return("4>");
X    case 4: return("3>");
X    case 5: return("2>");
X    case 6: return("1>");
X    case 7: return("><");
X    case 8: return("<1");
X    case 9: return("<2");
X    case 10: return("<3");
X    case 11: return("<4");
X    case 12: return("<5");
X    case 13: return("<6");
X    case 14: return("<7");
X    }
X    return("*");
X}
X
Xchar *
Xvisreverbtype(v)
X{
X    switch (v) {
X    case 0: return("ROOM 1");
X    case 1: return("ROOM 2");
X    case 2: return("HALL 1");
X    case 3: return("HALL 2");
X    case 4: return("PLATE");
X    case 5: return("DELAY 1");
X    case 6: return("DELAY 2");
X    case 7: return("DELAY 3");
X    case 8: return("OFF");
X    }
X    return("*");
X}
X
Xchar *visreverbtime(v)
X{
Xstatic char visreverbtimebuf[2];
X
X    if((v >= 0) && (v <= 7)) {
X        sprintf(visreverbtimebuf,"%d",v + 1);
X        return(visreverbtimebuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *visreverblevel(v)
X{
Xstatic char visreverblevelbuf[2];
X
X    if((v >= 0) && (v <= 7)) {
X        sprintf(visreverblevelbuf,"%d",v);
X        return(visreverblevelbuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *vispatchlevel(v)
X{
Xstatic char vispatchlevelbuf[4];
X
X    if((v >= 0) && (v <= 100)) {
X        sprintf(vispatchlevelbuf,"%d",v);
X        return(vispatchlevelbuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *
Xviskeymode(v)
X{
X    switch (v) {
X    case 0: return("WHOLE");
X    case 1: return("DUAL");
X    case 2: return("SPLIT");
X    }
X    return("*");
X}
X
Xstatic    char *split_table[] = {
X    "C",
X    "C#",
X    "D",
X    "D#",
X    "E",
X    "F",
X    "F#",
X    "G",
X    "G#",
X    "A",
X    "A#",
X    "B"
X};
X
Xchar *
Xvissplit(v)
X{
Xstatic    char    vissplitbuf[4];
X
X    if((v >= 0) && (v <= 61)) {
X        strcpy(vissplitbuf, split_table[v % 12]);
X        if(strlen(vissplitbuf) == 1) {
X            vissplitbuf[1] = (((v / 12) + 2) + '0');
X            vissplitbuf[2] = 0;
X        } else {
X            vissplitbuf[2] = (((v / 12) + 2) + '0');
X            vissplitbuf[3] = 0;
X        }
X        return(vissplitbuf);
X    } else {
X    return("*");
X    }
X}
X
Xchar *
Xvistonegroup(v)
X{
X    switch (v) {
X    case 0: return("A");
X    case 1: return("B");
X    case 2: return("I");
X    case 3: return("R");
X    }
X    return("*");
X}
X
Xchar *
Xvisrtone(v)
X{
Xstatic char visrtonebuf[4];
X    if(v >= 0 && v <= 127) {
X        if(v < 64) {
X            sprintf(visrtonebuf,"% 02d",v + 1);
X            visrtonebuf[0] = 'I';
X        } else {
X            if(v == 127) {
X                strcpy(visrtonebuf, "OFF");
X            } else {
X                v -= 64;
X                sprintf(visrtonebuf," %02d",v + 1);
X                visrtonebuf[0] = 'R';
X            }
X        }
X        return(visrtonebuf);
X    }
X    return("*");
X}
X
Xchar *vistonenum(v)
X{
Xstatic char vistonenumbuf[3];
X
X    if((v >= 0) && (v <= 63)) {
X        sprintf(vistonenumbuf,"%02d",v + 1);
X        return(vistonenumbuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *viskeyshift(v)
X{
Xstatic char viskeyshiftbuf[4];
X
X    if((v >= 0) && (v <= 23)) {
X        sprintf(viskeyshiftbuf,"-%d",abs(v - 24));
X        return(viskeyshiftbuf);
X    } else if(v == 24) {
X        sprintf(viskeyshiftbuf,"0");
X        return(viskeyshiftbuf);
X    } else if((v >= 25) && (v <= 48)) {
X        sprintf(viskeyshiftbuf,"+%d", (v - 24));
X        return(viskeyshiftbuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *visfinetune(v)
X{
Xstatic char visfinetunebuf[4];
X
X    if((v >= 0) && (v <= 49)) {
X        sprintf(visfinetunebuf,"-%d",abs(v - 50));
X        return(visfinetunebuf);
X    } else if(v == 50) {
X        sprintf(visfinetunebuf,"0");
X        return(visfinetunebuf);
X    } else if((v >= 51) && (v <= 100)) {
X        sprintf(visfinetunebuf,"+%d",(v - 50));
X        return(visfinetunebuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *visbendrange(v)
X{
Xstatic char visbendrangebuf[3];
X
X    if((v >= 0) && (v <= 24)) {
X        sprintf(visbendrangebuf,"%d",v);
X        return(visbendrangebuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *visassignmode(v)
X{
Xstatic char visassignmodebuf[2];
X
X    if((v >= 0) && (v <= 3)) {
X        sprintf(visassignmodebuf,"%d",v);
X        return(visassignmodebuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *vistonebal(v)
X{
Xstatic char vistonebalbuf[30];
Xstatic char vistonebalbuf1[30];
Xint n;
X
X    if((v >= 0) && (v <= 100)) {
X        sprintf(vistonebalbuf,"%d", v);
X        for(n = 0 ; n < (30 - strlen(vistonebalbuf)) ; n++)
X            strcat(vistonebalbuf, " ");
X        sprintf(vistonebalbuf1,"%d", abs(v - 100));
X        strcat(vistonebalbuf, vistonebalbuf1);
X        return(vistonebalbuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *
Xvisstruct(v)
X{
X    if((v >= 0) && (v <= 12)) {
X        switch(v) {
X            case 0:
X                return("~l~l~u~u~u __|_ ~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~lS 1  S");
X                break;
X            case 1:
X                return("~l~l~u~u~u __|  ~d~l~l~l~l~l~l| RM  ~d~l~l~l~l~l~l|/  \\ ~d~l~l~l~l~l~lS 2  S");
X                break;
X            case 2:
X                return("~l~l~u~u~u __|_ ~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~lP 3  S");
X                break;
X            case 3:
X                return("~l~l~u~u~u __|  ~d~l~l~l~l~l~l| RM  ~d~l~l~l~l~l~l|/  \\ ~d~l~l~l~l~l~lP 4  S");
X                break;
X            case 4:
X                return("~l~l~u~u~u __|  ~d~l~l~l~l~l~l| RM  ~d~l~l~l~l~l~l|/  \\ ~d~l~l~l~l~l~lS 5  P");
X                break;
X            case 5:
X                return("~l~l~u~u~u __|_ ~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~lP 6  P");
X                break;
X            case 6:
X                return("~l~l~u~u~u __|  ~d~l~l~l~l~l~l| RM  ~d~l~l~l~l~l~l|/  \\ ~d~l~l~l~l~l~lP 7  P");
X                break;
X            case 7:
X                return("~l~l~u~u~u|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~lS 8  S");
X                break;
X            case 8:
X                return("~l~l~u~u~u|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~l|    |~d~l~l~l~l~l~lP 9  P");
X                break;
X            case 9:
X                return("~l~l~u~u~u   |  ~d~l~l~l~l~l~l  RM  ~d~l~l~l~l~l~l /  \\ ~d~l~l~l~l~l~lS 10 S");
X                break;
X            case 10:
X                return("~l~l~u~u~u   |  ~d~l~l~l~l~l~l  RM  ~d~l~l~l~l~l~l /  \\ ~d~l~l~l~l~l~lP 11 S");
X                break;
X            case 11:
X                return("~l~l~u~u~u   |  ~d~l~l~l~l~l~l  RM  ~d~l~l~l~l~l~l /  \\ ~d~l~l~l~l~l~lS 12 P");
X                break;
X            case 12:
X                return("~l~l~u~u~u   |  ~d~l~l~l~l~l~l  RM  ~d~l~l~l~l~l~l /  \\ ~d~l~l~l~l~l~lP 13 P");
X                break;
X        }
X    } else {
X        return("*");
X    }
X}
X
Xchar *
Xvispmute(v)
X{
X    switch (v) {
X    case 0: return("_    _    _    _");
X    case 1: return("1    _    _    _");
X    case 2: return("_    2    _    _");
X    case 3: return("1    2    _    _");
X    case 4: return("_    _    3    _");
X    case 5: return("1    _    3    _");
X    case 6: return("_    2    3    _");
X    case 7: return("1    2    3    _");
X    case 8: return("_    _    _    4");
X    case 9: return("1     _   _    4");
X    case 10: return("_    2    _    4");
X    case 11: return("1    2    _    4");
X    case 12: return("_    _    3    4");
X    case 13: return("1    _    3    4");
X    case 14: return("_    2    3    4");
X    case 15: return("1    2    3    4");
X    }
X    return("*");
X}
X
Xchar *
Xvisenvmode(v)
X{
X    switch (v) {
X    case 0: return("NORMAL");
X    case 1: return("NO SUSTAIN");
X    }
X    return("*");
X}
X
Xstatic    char *cpitch_table[] = {
X    "C",
X    "C#",
X    "D",
X    "D#",
X    "E",
X    "F",
X    "F#",
X    "G",
X    "G#",
X    "A",
X    "A#",
X    "B"
X};
X
Xchar *
Xviscpitch(v)
X{
Xstatic    char    viscpitchbuf[4];
X
X    if((v >= 0) && (v <= 96)) {
X        strcpy(viscpitchbuf, cpitch_table[v % 12]);
X        if(strlen(viscpitchbuf) == 1) {
X            viscpitchbuf[1] = (((v / 12) + 1) + '0');
X            viscpitchbuf[2] = 0;
X        } else {
X            viscpitchbuf[2] = (((v / 12) + 1) + '0');
X            viscpitchbuf[3] = 0;
X        }
X        return(viscpitchbuf);
X    } else {
X    return("*");
X    }
X}
X
Xchar *
Xvispkeyfol(v)
X{
X    switch (v) {
X    case 0: return("-1");
X    case 1: return("-1/2");
X    case 2: return("-1/4");
X    case 3: return("0");
X    case 4: return("1/8");
X    case 5: return("1/4");
X    case 6: return("3/8");
X    case 7: return("1/2");
X    case 8: return("5/8");
X    case 9: return("3/4");
X    case 10: return("7/8");
X    case 11: return("1");
X    case 12: return("5/4");
X    case 13: return("3/2");
X    case 14: return("2");
X    case 15: return("s1");
X    case 16: return("s2");
X    }
X    return("*");
X}
X
Xchar *
Xvistkeyfol(v)
X{
X    switch (v) {
X    case 0: return("-1");
X    case 1: return("-1/2");
X    case 2: return("-1/4");
X    case 3: return("0");
X    case 4: return("1/8");
X    case 5: return("1/4");
X    case 6: return("3/8");
X    case 7: return("1/2");
X    case 8: return("5/8");
X    case 9: return("3/4");
X    case 10: return("7/8");
X    case 11: return("1");
X    case 12: return("5/4");
X    case 13: return("3/2");
X    case 14: return("2");
X    }
X    return("*");
X}
X
Xchar *viswavebank(v)
X{
X    switch (v) {
X    case 0: return("SQU1");
X    case 1: return("SAW1");
X    case 2: return("SQU2");
X    case 3: return("SAW2");
X    }
X    return("*");
X}
X
Xchar *vispcmnum(v)
X{
Xstatic char vispcmnumbuf[3];
X
X    if((v >= 0) && (v <= 127)) {
X        sprintf(vispcmnumbuf,"%d",v + 1);
X        return(vispcmnumbuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *visvelsens(v)
X{
Xstatic char visvelsensbuf[3];
X
X    if((v >= 0) && (v <= 6)) {
X        sprintf(visvelsensbuf,"-%d",abs(v - 7));
X        return(visvelsensbuf);
X    } else if(v == 7) {
X        sprintf(visvelsensbuf,"0");
X        return(visvelsensbuf);
X    } else if((v >= 8) && (v <= 14)) {
X        sprintf(visvelsensbuf,"+%d",abs(v - 7));
X        return(visvelsensbuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *visenvlev(v)
X{
Xstatic char visenvlevbuf[4];
X
X    if((v >= 0) && (v <= 49)) {
X        sprintf(visenvlevbuf,"-%d",abs(v - 50));
X        return(visenvlevbuf);
X    } else if(v == 50) {
X        sprintf(visenvlevbuf,"0");
X        return(visenvlevbuf);
X    } else if((v >= 51) && (v <= 100)) {
X        sprintf(visenvlevbuf,"+%d",abs(v - 50));
X        return(visenvlevbuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *visbiaslev(v)
X{
Xstatic char visbiaslevbuf[3];
X
X    if((v >= 0) && (v <= 6)) {
X        sprintf(visbiaslevbuf,"-%d",abs(v - 7));
X        return(visbiaslevbuf);
X    } else if(v == 7) {
X        sprintf(visbiaslevbuf,"0");
X        return(visbiaslevbuf);
X    } else if((v >= 8) && (v <= 14)) {
X        sprintf(visbiaslevbuf,"+%d",abs(v - 7));
X        return(visbiaslevbuf);
X    } else {
X        return("*");
X    }
X}
X
Xstatic    char *bpitch_table[] = {
X    "A",
X    "A#",
X    "B",
X    "C",
X    "C#",
X    "D",
X    "D#",
X    "E",
X    "F",
X    "F#",
X    "G",
X    "G#"
X};
X
Xchar *
Xvisbiaspd(v)
X{
Xstatic    char    visbiaspdbuf[5];
Xstatic    char    visbiaspdbuf1[2];
X
X    if((v >= 0) && (v <= 127)) {
X        if(v >= 64) {
X            strcpy(visbiaspdbuf, ">");
X            v -= 64;
X        } else {
X            strcpy(visbiaspdbuf, "<");
X        }
X        strcat(visbiaspdbuf, bpitch_table[v % 12]);
X        v += 9;
X        sprintf(visbiaspdbuf1, "%d", (v / 12) + 1);
X        strcat(visbiaspdbuf, visbiaspdbuf1);
X        return(visbiaspdbuf);
X    } else {
X        return("*");
X    }
X}
X
Xchar *vistvablev(v)
X{
Xstatic char vistvablevbuf[4];
X
X    if((v >= 0) && (v <= 12)) {
X        if(v == 12) {
X            return("0");
X        } else {
X            sprintf(vistvablevbuf,"-%d",abs(v - 12));
X            return(vistvablevbuf);
X        }
X    } else {
X        return("*");
X    }
X}
X
X/* end */
END_OF_FILE
if test 10248 -ne `wc -c <'vis.c'`; then
    echo shar: \"'vis.c'\" unpacked with wrong size!
fi
# end of 'vis.c'
fi
echo shar: End of archive 5 \(of 15\).
cp /dev/null ark5isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 15 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0